---
import { type CollectionEntry, getCollection } from "astro:content";
import { render } from "astro:content";
import Translations from "@components/Translations.astro";
import KeywordsList from "@components/organisms/KeywordsList.astro";
import Citations from "@components/Citations.astro";
import Signature from "@components/templates/signature/Signature.astro";
import CopyrightNotice from "@components/templates/CopyrightNotice.astro";
import { verifier as verifierPrototype } from "@lib/pgp/verify";
import {
  fromPosts,
  getSigners,
  getSignersIDs,
  isTranslation,
  licenseNotice,
  licenseURL,
} from "@lib/collection/helpers";
import { defined, get, transform } from "@utils/anonymous";
import Authors from "@components/templates/Authors.astro";
import Base from "@layouts/Base.astro";
import type {
  GetStaticPaths,
  InferGetStaticParamsType,
  InferGetStaticPropsType,
} from "astro";
import DateTime from "@components/organisms/Date.astro";
import { getUserIDsFromKey } from "@lib/pgp/user";
import type { PublicKey, UserIDPacket } from "openpgp";
import type { BlogPosting, Person } from "@lib/collection/types";
import {
  type MicroEntry,
  Original,
  type OriginalEntry,
  Translation,
} from "@lib/collection/schemas";
import { getEntry } from "astro:content";
import { getEntries } from "astro:content";
import readingTime from "reading-time";
import { fileCreationCommitDate } from "@lib/git/log";

export const getStaticPaths = (async (): Promise<
  {
    params: { slug: string };
    props: CollectionEntry<"blog">;
  }[]
> => {
  const posts = await getCollection("blog");
  return posts.map((post) => ({
    params: { slug: post.id },
    props: post,
  }));
}) satisfies GetStaticPaths;

type Params = InferGetStaticParamsType<typeof getStaticPaths>;
type Props = InferGetStaticPropsType<typeof getStaticPaths>;

let post: Props | undefined = Astro.props;

const verifier = await verifierPrototype.then((x) => x.clone());

const signers: Map<
  string,
  {
    signer: Awaited<ReturnType<typeof getSigners>>[number];
    users: UserIDPacket[];
    key: PublicKey;
  }
> = new Map();
// Add signers public keys to keyring
for (const signer of await getSigners(post)) {
  const { data } = signer.entity;
  const key = await verifier.addKeyFromArmor(data.publickey.armor);
  signers.set(key.getFingerprint(), {
    signer,
    users: getUserIDsFromKey(undefined, key),
    key,
  });
}

const createPerson = (
  { signer, users }: typeof signers extends Map<any, infer V> ? V : never,
): Person | undefined => ({
  "@type": "Person",
  "@id": signer.entity.id, // TODO: URL
  name: users.find(({ name }) => name.length > 0)?.name,
  url: signer.entity.data.websites,
  email: users.find(({ email }) => email.length > 0)?.email,
});

const signersValues = Array.from(signers.values());
const author: Person | undefined = transform(
  signersValues.find(({ signer }) => signer.role === "author"),
  (x) => x !== undefined ? createPerson(x) : undefined,
);
const coauthors: Person[] = signersValues.filter(({ signer }) =>
  signer.role === "co-author"
).map(createPerson).filter(defined);
const translators: Person[] = signersValues.filter(({ signer }) =>
  signer.role === "translator"
).map(createPerson).filter(defined);

const { id, data, rendered, body, filePath } = post;

const path = new URL(`file://${Deno.cwd()}/${filePath}`);
const verification = post.filePath !== undefined
  ? await verifier.verify([path])
  : undefined;

const commit = await verification?.commit;

const { title, lang, dateCreated, dateUpdated, license } = data;

let original: OriginalEntry | MicroEntry;
try {
  const { translationOf } = Translation.parse(post);
  const maybeOriginal = await getEntry(translationOf) as
    | OriginalEntry
    | MicroEntry
    | undefined;

  if (maybeOriginal === undefined) {
    throw new Error(`Original post not found for ${id}`);
  }

  original = maybeOriginal;

  const { author: [originalAuthors], "co-author": originalCoauthors } =
    getSignersIDs(original);
  const originalAuthor = originalAuthors?.[0];

  if (
    (author !== undefined &&
      author["@id"] !== originalAuthor) ||
    !new Set(coauthors).isSubsetOf(new Set(originalCoauthors))
  ) {
    throw new Error(
      `Post ${id} has mismatched (co-)authors from original post ${original.id}`,
    );
  }

  for (const { "@id": t } of translators) {
    if (
      originalAuthor === t || originalCoauthors.includes(t)
    ) {
      throw new Error(
        `Translator ${t} in ${id} is already a (co-)author in original post`,
      );
    }
  }
} catch {
  original = post as OriginalEntry | MicroEntry;
  if (signersValues.some(({ signer }) => signer.role === "translator")) {
    throw new Error(
      `Post ${id} is not a translation but has translators defined`,
    );
  }
}

const translationsSet = await fromPosts(
  isTranslation,
  (x) =>
    new Set(
      x.filter(({ data }) => data.translationOf.id === original.id).map(
        get("id"),
      ),
    ),
);
translationsSet.add(original.id);

const translations = await getEntries(
  Array.from(translationsSet).map((id) => ({
    collection: original.collection,
    id,
  })),
);

const reading = body ? readingTime(body, {}) : undefined;
const minutes = reading === undefined
  ? undefined
  : Math.ceil(reading.minutes);
const estimative = minutes === undefined
  ? undefined
  : new Intl.DurationFormat(lang, {
    style: "long",
  }).format({ hours: Math.floor(minutes / 60), minutes: minutes % 60 });
const duration = minutes === undefined
  ? undefined
  : `PT${Math.floor(minutes / 60) > 0 ? Math.floor(minutes / 60) + "H" : ""}${
    minutes % 60 > 0 ? minutes % 60 + "M" : ""
  }`;

const linkedData: BlogPosting & { "@context": "https://schema.org" } = {
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "@id": Astro.url.href,
  url: Astro.url.href,
  headline: title,
  name: title,
  abstract: "description" in data ? data.description : undefined,
  alternativeHeadline: "subtitle" in data ? data.subtitle : undefined,
  inLanguage: lang,
  workTranslations: translations.filter((post) =>
    post.id !== id && post.id !== original.id
  ).map(({ id, data }) =>
    ({
      "@type": "BlogPosting",
      "@id": new URL(`blog/read/${id}`, Astro.site).href,
      url: new URL(`blog/read/${id}`, Astro.site).href,
      headline: data.title,
      name: data.title,
      inLanguage: data.lang,
      dateCreated: data.dateCreated.toISOString(),
      license: licenseURL(data.license)?.href,
      translator: data.signers.filter(({ role }) => role === "translator")
        .map((
          { entity },
        ): Person => ({
          "@type": "Person",
          "@id": entity.id,
        })),
    }) as BlogPosting
  ),
  translationOfWork: original.id !== post.id
    ? {
      "@type": "BlogPosting",
      "@id": new URL(`blog/read/${original.id}`, Astro.site).href,
      url: new URL(`blog/read/${original.id}`, Astro.site).href,
      headline: original.data.title,
      name: original.data.title,
      inLanguage: original.data.lang as string,
      dateCreated: original.data.dateCreated.toISOString(),
      license: licenseURL(original.data.license)?.href,
    } as BlogPosting
    : undefined,
  // TODO: version
  author,
  contributor: coauthors,
  translator: translators,
  dateCreated: dateCreated.toISOString(),
  dateModified: dateUpdated?.toISOString(),
  datePublished: await fileCreationCommitDate(path).then((date) =>
    date?.toISOString()
  ),
  timeRequired: duration,
  wordCount: reading?.words,
  articleBody: rendered?.html ?? body,
  text: rendered?.html ?? body,
  keywords: original.data.keywords,
  citation: await transform(
    Original.safeParse(original.data).data,
    async (o) => {
      if (o === undefined) return o;
      const related = await getEntries(o.relatedPosts);
      return related.map(({ data }): BlogPosting => ({
        "@type": "BlogPosting",
        "@id": new URL(`blog/read/${id}`, Astro.site).href,
        url: new URL(`blog/read/${id}`, Astro.site).href,
        headline: data.title,
        name: data.title,
        inLanguage: data.lang,
        dateCreated: data.dateCreated.toISOString(),
        license: licenseURL(data.license)?.href ?? undefined,
      }));
    },
  ), // TODO: citation V.S. mentions
  mentions: await transform(
    Original.safeParse(original.data).data,
    async (o) => {
      if (o === undefined) return o;
      const related = await getEntries(o.relatedPosts);
      return related.map(({ data }): BlogPosting => ({
        "@type": "BlogPosting",
        "@id": new URL(`blog/read/${id}`, Astro.site).href,
        url: new URL(`blog/read/${id}`, Astro.site).href,
        headline: data.title,
        name: data.title,
        inLanguage: data.lang,
        dateCreated: data.dateCreated.toISOString(),
        license: licenseURL(data.license)?.href ?? undefined,
      }));
    },
  ), // TODO: citation V.S. mentions
  copyrightHolder: [author, ...coauthors, ...translators].filter(defined),
  copyrightNotice: licenseNotice(license, {
    title,
    holders: signersValues.map(({ users }) => {
      const user = users?.[0];
      if (user === undefined) return undefined;

      const { name, email } = user;

      return (name.length > 0 && email.length > 0)
        ? { name, email }
        : undefined;
    }).filter(defined),
    years: new Array( // TODO: get years where there were commits
      (dateUpdated?.getFullYear() ?? dateCreated.getFullYear()) -
        dateCreated.getFullYear() + 1,
    ).fill(dateCreated.getFullYear()).map((x, i) => x + i),
  }, lang),
  copyrightYear: dateCreated.getFullYear(),
  creativeWorkStatus: "Published",
  encodingFormat: "text/html",
  isAccessibleForFree: true,
  license: licenseURL(license)?.href ?? undefined,
  publisher: transform(commit?.committer, (commiter) => {
    if (commiter === undefined) return undefined;

    const { name, email } = commiter;

    return {
      "@type": "Person",
      name,
      email,
    };
  }),
};

const { Content } = await render(post);

post = undefined;
---

<Base
  title={linkedData.headline}
  description={linkedData.abstract ?? linkedData.headline}
>
  <main
    itemprop="mainContentOfPage"
    itemscope
    itemtype="https://schema.org/WebPageElement"
  >
    <article
      itemscope
      itemtype="http://schema.org/BlogPosting"
      itemid={Astro.url.href}
    >
      <Translations
        id={linkedData["@id"]}
        lang={linkedData.inLanguage}
        workTranslations={linkedData.workTranslations ?? []}
        translationOfWork={linkedData.translationOfWork}
      />
      <hgroup>
        <h1 itemprop="headline">{linkedData.headline}</h1>
        {
          linkedData.alternativeHeadline && (
            <p itemprop="alternativeHeadline" class="subtitle">
              {linkedData.alternativeHeadline}
            </p>
          )
        }
      </hgroup>
      {
        linkedData.abstract &&
  (
          <section itemprop="abstract">
            <h2>Resumo</h2>
            {
              linkedData.abstract.split(new RegExp("\\s{2,}"))
                .map((
                  x,
                ) => <p>{x}</p>)
            }
          </section>
        )
      }
      {verification && <Signature {lang} {verification} />}
      <footer>
        {
          verification?.verifications &&
  (
            <Authors
              verifications={verification.verifications}
              expectedSigners={signers}
              commitSignerKey={commit?.signature?.key.long}
            />
          )
        }
        <dl>
          <dt>Data de criação</dt>
          <dd>
            <DateTime
              date={new Date(linkedData.dateCreated)}
              locales={linkedData.inLanguage}
              options={{
                weekday: "long",
                year: "numeric",
                month: "long",
                day: "numeric",
                hour: "2-digit",
                minute: "2-digit",
                timeZoneName: "long",
              }}
              itemprop="dateCreated"
            />
          </dd>
          {
            linkedData.dateModified && (
              <dt>Última atualização</dt>
              <dd>
                <DateTime
                  date={new Date(linkedData.dateModified)}
                  locales={linkedData.inLanguage}
                  options={{
                    weekday: "long",
                    year: "numeric",
                    month: "long",
                    day: "numeric",
                    hour: "2-digit",
                    minute: "2-digit",
                    timeZoneName: "long",
                  }}
                  itemprop="dateModified"
                />
              </dd>
            )
          }
          {
            linkedData.locationCreated && (
              <div
                itemprop="locationCreated"
                itemscope
                itemtype="https://schema.org/Place"
              >
                <dt>Local de criação</dt>
                <dd itemprop="name">{linkedData.locationCreated.name}</dd>
              </div>
            )
          }
          {
            linkedData.wordCount && linkedData.timeRequired &&
  (
              <>
                <dt>Tempo de leitura estimado</dt>
                <dd>
                  <data
                    itemprop="timeRequired"
                    value={linkedData.timeRequired}
                  >~ {estimative}</data>
                  <data itemprop="wordCount" value={linkedData.wordCount}
                  >(<bdi>palavras</bdi>: {linkedData.wordCount})</data>
                </dd>
              </>
            )
          }
        </dl>
      </footer>
      <div itemprop="articleBody text"><Content /></div>
      {
        linkedData.keywords !== undefined &&
          linkedData.keywords.length > 0 && (
          <div id="keywords">
            <KeywordsList keywords={linkedData.keywords} />
          </div>
        )
      }
      {
        linkedData.citation !== undefined && (
          <Citations citations={linkedData.citation} />
        )
      }
      <CopyrightNotice
        title={linkedData.headline}
        holders={linkedData.copyrightHolder ?? [{ "@type": "Person" }]}
        years={new Array( // TODO: get years where there were commits
          (dateUpdated?.getFullYear() ?? dateCreated.getFullYear()) -
            dateCreated.getFullYear() + 1,
        ).fill(dateCreated.getFullYear()).map((x, i) => x + i)}
        {license}
      />
    </article>
  </main>
</Base>

<script
  type="application/ld+json"
  is:inline
  set:html={JSON.stringify(linkedData)}
/>

<script type="module" is:inline>
  hashchange();

  window.addEventListener("hashchange", hashchange);

  document.addEventListener(
    "click",
    function (event) {
      if (
        event.target &&
        event.target instanceof HTMLAnchorElement &&
        event.target.href === location.href &&
        location.hash.length > 1
      ) {
        requestIdleCallback(function () {
          if (!event.defaultPrevented) {
            hashchange();
          }
        });
      }
    },
    false,
  );

  function hashchange() {
    let hash;

    try {
      hash = decodeURIComponent(location.hash.slice(1)).toLowerCase();
    } catch (e) {
      return;
    }

    const name = "user-content-" + hash;
    const target = document.getElementById(name) ||
      document.getElementsByName(name)[0];

    if (target) {
      requestIdleCallback(function () {
        target.scrollIntoView();
      });
    }
  }
</script>

<style is:inline>
  section[data-footnotes].footnotes {
    word-wrap: break-word;
  }
</style>

<style>
  hgroup {
    text-align: center;
  }

  .subtitle {
    font-weight: lighter;
  }

  #keywords {
    display: flex;
    margin-inline: auto;
    margin-block: calc(var(--size-4) * 1em);
  }

  [itemprop~="articleBody"] {
    line-height: 1.4;
    font-size: 1.2em;
    text-align: justify;

    & h1,
    & h2,
    & h3 {
      line-height: 1.2;
    }

    border-block: 1px solid var(--color-dark);
    padding-block: calc(var(--size-4) * 1em);
  }

  [itemprop="abstract"] {
    margin-inline: 1em;
    padding-block: 1em;
    font-style: italic;
  }

  @media print {
    body {
      font-size: 1rem;
      font-family: var(--ff-serif);
      line-height: 1.62;
    }
  }
</style>